RAPPORT-ATL-5

SpringBoot ?

Spring Boot est un framework open-source pour le développement d'applications Java. Il fournit un environnement prêt à l'emploi pour développer des applications avec une configuration minimale. Spring Boot facilite la création d'applications autonomes qui peuvent être facilement déployées. Il est également extensible et peut être utilisé avec d'autres frameworks de Spring.

Spring Boot Layers

Spring Boot est composé des quatre couches suivantes :

La couche de présentation - cette couche est responsable de l'authentification et de la traduction Json. Elle gère également les interactions avec l'utilisateur et fournit une interface utilisateur pour l'application.

La couche métier - cette couche est responsable de la logique métier, de la validation et de l'autorisation. Elle implémente les règles métier de l'application et assure que les données entrantes sont valides et autorisées.

La couche de persistance - cette couche est responsable de la logique de stockage. Elle gère la communication avec la base de données et assure la persistance des données de l'application.

La couche de base de données - cette couche est responsable de la gestion de la base de données elle-même. Elle stocke les données de l'application et fournit des opérations pour récupérer et modifier ces données.

Spring Boot Architecture flow

Bean Life Cycle

MVC

Spring Boot MVC est une implémentation du modèle-vue-contrôleur (MVC) pour les applications Web Spring Boot.

Le modèle-vue-contrôleur est un motif de conception qui divise une application en trois parties distinctes pour mieux séparer les préoccupations :

Le modèle - représente les données de l'application.

La vue - représente l'interface utilisateur de l'application.

Le contrôleur - gère les requêtes HTTP et coordonne l'interaction entre le modèle et la vue.

En utilisant Spring Boot MVC, vous pouvez facilement construire des applications Web robustes et évolutives avec un code clair et facile à maintenir.

Project Code Structure

├── HELP.md
├── mvnw
├── mvnw.cmd
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── me
    │   │       └── ynabouzi
    │   │           └── atelier5
    │   │               ├── Atelier5Application.java
    │   │               ├── controller
    │   │               │   └── AppController.java
    │   │               ├── models
    │   │               │   ├── Registration.java
    │   │               │   └── Student.java
    │   │               ├── repository
    │   │               │   ├── RegistrationRepository.java
    │   │               │   └── StudentRepository.java
    │   │               ├── service
    │   │               │   ├── RegistrationService.java
    │   │               │   └── StudentService.java
    │   │               └── ServletInitializer.java
    │   └── resources
    │       ├── application.yml
    │       ├── static
    │       │   ├── css
    │       │   │   ├── error.css
    │       │   │   └── style.css
    │       │   ├── images
    │       │   │   ├── ensalogo.png
    │       │   │   └── Success.gif
    │       │   └── js
    │       │       ├── app.js
    │       │       └── error.js
    │       └── templates
    │           ├── error.html
    │           ├── index.html
    │           └── success.html
    └── test
        └── java
            └── me
                └── ynabouzi
                    └── atelier5
                        └── Atelier5ApplicationTests.java

HELP.md : fichier contenant des informations sur le projet et comment l'utiliser.

mvnw et mvnw.cmd : fichiers permettant de lancer l'outil de build Maven sur Linux/Unix et Windows respectivement.

pom.xml : fichier de configuration Maven contenant les dépendances et la configuration du projet.

src/main/java : dossier contenant les fichiers sources Java de l'application.

Atelier5Application.java : classe principale de l'application Spring Boot.

controller : package contenant les classes qui servent de contrôleurs pour l'application.

AppController.java : classe contenant des méthodes qui gèrent les requêtes HTTP.

models : package contenant les classes de modèles de données de l'application.

Registration.java et Student.java : classes représentant des entités de données de l'application.

repository : package contenant les interfaces de repository de l'application.

RegistrationRepository.java et StudentRepository.java : interfaces qui fournissent des méthodes pour accéder aux données dans la base de données.

service : package contenant les classes de service de l'application.

RegistrationService.java et StudentService.java : classes qui contiennent la logique métier de l'application.

ServletInitializer.java : classe qui configure la servlet de l'application.

resources : dossier contenant les fichiers de configuration et les fichiers statiques de l'application.

application.yml : fichier de configuration de l'application.

static : dossier contenant les fichiers statiques de l'application tels que les feuilles de style et les fichiers JavaScript.

Atelier5ApplicationTests.java : classe de test pour l'application Spring Boot.

Technologies

SpringBoot 🍃 : 3.0.6

MariaDB 🦭 : 10.11.2

Intelli : IntelliJ IDEA 2023.1 (Ultimate Edition)

Models

Le package models contient deux classes Java : Registration et Student, qui sont utilisées pour définir les modèles de données de l'application.

La classe Registration représente le formulaire d'inscription soumis par un étudiant.

La classe Student représente un étudiant enregistré dans le système.

Registration

@Data
@NoArgsConstructor
@ToString
@EqualsAndHashCode
@AllArgsConstructor
@Entity
@Table(name = "registration", schema = "ATELIER5")
public class Registration {
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Id
	@Column(name = "Id_reg", nullable = false)
	private long Id_reg;
	@Basic
	@Column(name = "RegDate", nullable = true)
	private String RegDate;
	@Basic
	@Column(name = "Grouped", nullable = true, length = 30)
	private String Grouped;
	@Basic
	@Column(name = "Level", nullable = true, length = 30)
	private String Level;
	@Basic
	@Column(name = "Major", nullable = true, length = 30)
	private String Major;

	@ManyToOne(fetch = FetchType.LAZY)
	@ToString.Exclude
	@JoinColumn(name = "Student_id", referencedColumnName = "Id_std")
	private Student Student;
}

Student

@Data
@NoArgsConstructor
@ToString
@EqualsAndHashCode
@AllArgsConstructor
@Entity
@Table(name = "student", schema = "ATELIER5")
public class Student {
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Id
	@Column(name = "Id_std", nullable = false)
	private long Id_std;
	@Basic
	@Column(name = "LastName", nullable = true, length = 20)
		private String LastName;
	@Basic
	@Column(name = "FirstName", nullable = true, length = 20)
	private String FirstName;
	@Basic
	@Column(name = "CIN", nullable = true, length = 20)
	private String CIN;
	@Basic
	@Column(name = "Email", nullable = true, length = 255)
	private String Email;
	@Basic
	@Column(name = "BirthDate", nullable = true, length = 255)
	private String BirthDate;
	@Basic
	@Column(name = "PhoneNumber", nullable = true, length = 255)
	private String PhoneNumber;

	@OneToMany(cascade = CascadeType.ALL, mappedBy = "Student",orphanRemoval = true)
	@ToString.Exclude
	private List<Registration> re = new ArrayList<>();

}

Ces deux classes Java sont des modèles (ou entités) qui représentent les tables de la base de données.

La classe Registration a des champs correspondant aux colonnes de la table "registration" dans le schéma "ATELIER5". Elle possède également une relation ManyToOne (plusieurs inscriptions pour un seul étudiant) avec la classe Student, représentée par l'attribut "Student".

La classe Student a des champs correspondant aux colonnes de la table "student" dans le schéma "ATELIER5". Elle possède également une relation OneToMany (un seul étudiant pour plusieurs inscriptions) avec la classe Registration, représentée par l'attribut "re".

Repository and Services

Les classes Repository sont responsables de la persistance des données en relation avec la base de données. Dans notre modèle, nous avons deux classes Repository: StudentRepository et RegistrationRepository. Ces classes fournissent des méthodes pour créer, lire, mettre à jour et supprimer des entités de la base de données correspondant à ces modèles.

Les classes de service fournissent des fonctionnalités métier pour le modèle et agissent comme un intermédiaire entre les contrôleurs et les classes Repository. Dans notre modèle, nous avons deux classes de service: StudentService et RegistrationService. Ces classes fournissent des méthodes pour ajouter un nouvel étudiant ou une nouvelle inscription à la base de données. Elles utilisent les classes Repository correspondantes pour effectuer ces opérations de base de données. Les services peuvent également implémenter des règles de validation métier et peuvent implémenter des logiques plus complexes impliquant plusieurs entités.

Repository Interfaces

public interface RegistrationRepository extends JpaRepository<Registration, Long> {
}

public interface StudentRepository extends JpaRepository<Student, Long> {
	@Query("SELECT s from Student s WHERE s.Email = ?1")
	Optional<Student> findStudentByEmail(String email);
}

Service classes

@Service
public class RegistrationService {
	private final RegistrationRepository registrationRepository;

	@Autowired
	public RegistrationService(RegistrationRepository registrationRepository) {
		this.registrationRepository = registrationRepository;
	}

	public void addNewRegistration(Registration registration){
		registrationRepository.save(registration);
	}

	public RegistrationRepository getRegistrationRepository() {
		return registrationRepository;
	}
}

@Service
public class StudentService {
	private final StudentRepository studentRepository;

	@Autowired
	public StudentService(StudentRepository studentRepository) {
		this.studentRepository = studentRepository;
	}

	public List<Student> getStudent(){
		return studentRepository.findAll();
	}

	public void addNewStudent(Student student){
		Optional<Student> studentByEmail = studentRepository.findStudentByEmail(student.getEmail());
		if (studentByEmail.isPresent()){
			throw new IllegalStateException("The email you enter is already taken!");
		}
		studentRepository.save(student);
	}
}

Controllers

@Controller
public class AppController {
	private final RegistrationService registrationService;
	private final StudentService studentService;

	@Autowired
	public AppController(RegistrationService registrationService, StudentService studentService) {
		this.registrationService = registrationService;
		this.studentService = studentService;
	}
	@GetMapping("/")
	public String index() {
		return "index";
	}

	@PostMapping("/register")
	public ModelAndView register(@ModelAttribute Registration registration, @ModelAttribute Student student)
	{
		studentService.addNewStudent(student);
		registration.setStudent(student);
		System.out.println("Registration from UI = "+ registration);
		System.out.println("Student from UI = "+ registration.getStudent());

		registrationService.addNewRegistration(registration);
		// Logique pour sauvegarder l'étudiant dans la base de données ou autre traitement
		ModelAndView modelAndview = new ModelAndView();
		modelAndview.setViewName("success");
		modelAndview.addObject("reg",registration);
		return modelAndview;
	}
}

Le contrôleur AppController est utilisé pour gérer les requêtes HTTP de l'application. Il a deux services en dépendance: RegistrationService et StudentService.

La méthode index() est annotée avec @GetMapping("/") qui signifie que cette méthode est appelée lorsqu'une requête GET est reçue avec le chemin d'accès "/", elle renvoie la vue "index".

La méthode register() est annotée avec @PostMapping("/register"), elle est appelée lorsqu'une requête POST est reçue avec le chemin d'accès "/register". Elle prend en entrée deux objets Registration et Student annotés avec @ModelAttribute qui contiennent les données soumises par le formulaire. Elle ajoute l'étudiant à la base de données en appelant la méthode addNewStudent() du StudentService. Elle définie l'étudiant pour l'objet registration et l'ajoute à la base de données en appelant la méthode addNewRegistration() du RegistrationService. Elle renvoie ensuite la vue "success" en utilisant l'objet ModelAndView.

Spring Boot App

@SpringBootApplication
public class Atelier5Application {
	public static void main(String[] args) {
		SpringApplication.run(Atelier5Application.class, args);
	}
}

La classe Atelier5Application est la classe principale de l'application Spring Boot. Elle est annotée avec @SpringBootApplication, ce qui signifie qu'elle est configurée pour fonctionner comme une application Spring Boot. Elle contient une méthode main qui lance l'application Spring Boot en appelant la méthode run de la classe SpringApplication avec la classe Atelier5Application et les arguments fournis. Cela initialise l'application Spring Boot, configure le contexte d'application et démarre le serveur Web.

Config Files

server:
  error:
    include-message: always
    include-binding-errors: always

spring:
  datasource:
    username: abmola
    password: "yasser1234"
    url: jdbc:mariadb://localhost:3306/ATELIER5?createDatabaseIfNotExist=true
  jpa:
    hibernate:
      ddl-auto: create-drop
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MariaDB10Dialect
        format_sql: true
    show-sql: true

Result

Ressources

JAVA DOC : HERE

SOURCE CODE : HERE

Made with Love 🦢

by @NBGamer